Spring Boot 与 Kotlin 教程

1. Kotlin 简介和特性

Kotlin 是一种静态类型的编程语言，运行在 Java 虚拟机（JVM）上，并且可以编译成 JavaScript 源代码。Kotlin 由 JetBrains 开发，旨在提高开发效率和代码可读性。Kotlin 的主要特性包括：

• 简洁性：减少样板代码，提高代码可读性。
• 空安全：通过类型系统防止空指针异常。
• 互操作性：与 Java 完全兼容，可以无缝调用 Java 代码。
• 函数式编程：支持高阶函数、Lambda 表达式等。

2. 开发环境搭建

2.1 IntelliJ IDEA

IntelliJ IDEA 是 JetBrains 开发的一款强大的 IDE，特别适合 Kotlin 开发。以下是安装步骤：

1. 下载并安装 IntelliJ IDEA。
2. 打开 IntelliJ IDEA，选择 "New Project"。
3. 选择 "Kotlin" 作为项目类型，并选择 "JVM" 作为目标平台。
4. 配置项目名称和位置，点击 "Finish" 完成创建。

2.2 Android Studio

Android Studio 是 Google 官方推荐的 Android 开发 IDE，基于 IntelliJ IDEA 构建，同样支持 Kotlin。

1. 下载并安装 Android Studio。
2. 打开 Android Studio，选择 "New Project"。
3. 选择 "Empty Activity" 模板，并选择 Kotlin 作为编程语言。
4. 配置项目名称和位置，点击 "Finish" 完成创建。

3. 第一个 Kotlin 程序

创建一个简单的 Kotlin 程序，输出 "Hello, World!"。

fun main() {
    println("Hello, World!")
}

4. 基本语法和数据类型

4.1 变量和常量

• 变量：使用 var 关键字声明，可以重新赋值。
• 常量：使用 val 关键字声明，不可重新赋值。

var age: Int = 25
val name: String = "Alice"

4.2 数据类型

Kotlin 支持多种基本数据类型，包括：

• 数字类型：Int, Long, Float, Double
• 字符类型：Char
• 布尔类型：Boolean
• 字符串类型：String

val number: Int = 10
val letter: Char = 'A'
val isTrue: Boolean = true
val text: String = "Hello"

5. 条件语句

5.1 if 语句

val a = 10
val b = 20

if (a > b) {
    println("a is greater than b")
} else {
    println("b is greater than a")
}

5.2 when 语句

when 语句类似于 Java 中的 switch 语句，但功能更强大。

val day = 3

when (day) {
    1 -> println("Monday")
    2 -> println("Tuesday")
    3 -> println("Wednesday")
    else -> println("Other day")
}

6. 循环

6.1 for 循环

for (i in 1..5) {
    println(i)
}

6.2 while 循环

var i = 1
while (i <= 5) {
    println(i)
    i++
}

6.3 do-while 循环

var i = 1
do {
    println(i)
    i++
} while (i <= 5)

7. 跳转表达式

7.1 break

用于跳出循环。

for (i in 1..10) {
    if (i == 5) {
        break
    }
    println(i)
}

7.2 continue

用于跳过当前循环的剩余部分，继续下一次循环。

for (i in 1..5) {
    if (i == 3) {
        continue
    }
    println(i)
}

7.3 return

用于从函数中返回值。

fun add(a: Int, b: Int): Int {
    return a + b
}

8. 函数定义和调用

8.1 函数定义

fun greet(name: String): String {
    return "Hello, $name!"
}

8.2 函数调用

val message = greet("Alice")
println(message)

9. 默认参数和命名参数

9.1 默认参数

fun greet(name: String = "Guest"): String {
    return "Hello, $name!"
}

9.2 命名参数

val message = greet(name = "Bob")
println(message)

10. 单表达式函数

fun add(a: Int, b: Int) = a + b

11. Lambda 表达式

val sum = { x: Int, y: Int -> x + y }
println(sum(1, 2))

12. 高阶函数

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val result = operate(3, 4) { x, y -> x * y }
println(result)

13. 类定义和实例化

13.1 类定义

class Person(val name: String, var age: Int)

13.2 实例化

val person = Person("Alice", 25)
println("Name: ${person.name}, Age: ${person.age}")

14. 构造函数和初始化块

14.1 主构造函数

class Person(val name: String, var age: Int) {
    init {
        println("Person created with name: $name and age: $age")
    }
}

14.2 次构造函数

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0)
}

15. 属性和字段

class Person(val name: String, var age: Int) {
    var address: String = ""
        get() = field
        set(value) {
            field = value
        }
}

16. 继承和接口

16.1 继承

open class Animal(val name: String)

class Dog(name: String) : Animal(name)

16.2 接口

interface Greeter {
    fun greet(name: String): String
}

class Person(val name: String) : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

17. 数据类和密封类

17.1 数据类

data class User(val id: Int, val name: String)

val user = User(1, "Alice")
println(user)

17.2 密封类

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

18. 对象声明和表达式

18.1 对象声明

object Singleton {
    val name = "Singleton"
}

println(Singleton.name)

18.2 对象表达式

val greeter = object : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

println(greeter.greet("Alice"))

19. 可空类型和非空类型

19.1 可空类型

var name: String? = null

19.2 非空类型

var name: String = "Alice"

20. 安全调用操作符 (?.)

val name: String? = null
println(name?.length)

21. Elvis 操作符 (?:)

val name: String? = null
val length = name?.length ?: 0
println(length)

22. 非空断言 (!!)

val name: String? = "Alice"
println(name!!.length)

23. 平台类型

val name: String! = "Alice"
println(name.length)

24. List, Set, Map

24.1 List

val list = listOf("Apple", "Banana", "Cherry")
println(list)

24.2 Set

val set = setOf("Apple", "Banana", "Cherry")
println(set)

24.3 Map

val map = mapOf("Apple" to 1, "Banana" to 2, "Cherry" to 3)
println(map)

25. 可变集合和不可变集合

25.1 可变集合

val mutableList = mutableListOf("Apple", "Banana", "Cherry")
mutableList.add("Date")
println(mutableList)

25.2 不可变集合

val immutableList = listOf("Apple", "Banana", "Cherry")
// immutableList.add("Date") // 编译错误
println(immutableList)

26. 集合操作 (filter, map, reduce 等)

26.1 filter

val list = listOf(1, 2, 3, 4, 5)
val filteredList = list.filter { it % 2 == 0 }
println(filteredList)

26.2 map

val list = listOf(1, 2, 3, 4, 5)
val mappedList = list.map { it * 2 }
println(mappedList)

26.3 reduce

val list = listOf(1, 2, 3, 4, 5)
val sum = list.reduce { acc, i -> acc + i }
println(sum)

27. 序列 (Sequence)

val sequence = sequenceOf(1, 2, 3, 4, 5)
val result = sequence.filter { it % 2 == 0 }.map { it * 2 }.toList()
println(result)

28. 不可变性

val immutableList = listOf("Apple", "Banana", "Cherry")
// immutableList.add("Date") // 编译错误
println(immutableList)

29. 纯函数

fun add(a: Int, b: Int): Int {
    return a + b
}

30. 函数组合

fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int {
    return { x -> f(g(x)) }
}

val addOne = { x: Int -> x + 1 }
val double = { x: Int -> x * 2 }
val composed = compose(addOne, double)
println(composed(5))

31. 柯里化

fun add(a: Int) = { b: Int -> a + b }

val addFive = add(5)
println(addFive(10))

32. 协程基础

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

33. 挂起函数

import kotlinx.coroutines.*

suspend fun doSomething() {
    delay(1000L)
    println("Done")
}

fun main() = runBlocking {
    doSomething()
}

34. 协程上下文和调度器

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        println("Running on ${Thread.currentThread().name}")
    }
}

35. 通道和流

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close()
    }
    for (y in channel) println(y)
}

36. 异步编程模式

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async {
        delay(1000L)
        42
    }
    println("The answer is ${deferred.await()}")
}

37. 泛型函数和类

37.1 泛型函数

fun <T> printList(list: List<T>) {
    for (item in list) {
        println(item)
    }
}

val list = listOf(1, 2, 3)
printList(list)

37.2 泛型类

class Box<T>(val item: T)

val box = Box("Hello")
println(box.item)

38. 型变（协变和逆变）

38.1 协变

interface Producer<out T> {
    fun produce(): T
}

class ProducerImpl : Producer<String> {
    override fun produce(): String {
        return "Hello"
    }
}

val producer: Producer<Any> = ProducerImpl()
println(producer.produce())

38.2 逆变

interface Consumer<in T> {
    fun consume(item: T)
}

class ConsumerImpl : Consumer<String> {
    override fun consume(item: String) {
        println(item)
    }
}

val consumer: Consumer<Any> = ConsumerImpl()
consumer.consume("Hello")

39. 类型投影

fun copy(from: Array<out Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3) { "" }
copy(ints, any)
println(any.toList())

40. 泛型约束

fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a > b) a else b
}

println(max(1, 2))